﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Data.Linq;
using System.Text;
using GestorSQL.BusinessEntities;
using GestorSQL.Utility;

namespace GestorSQL.DAO
{
    public class GestorSqlDao : IGestorSqlDao
    {
        private string StrConn { get { return "GestorSQLConnectionString".GetFromConnStrings(); } }

        #region IGestorSqlDao Caso
        public void CreateCase(Caso caso)
        {
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                dc.Casos.InsertOnSubmit(caso);
                dc.SubmitChanges();
                dc.Historias.FirstOrDefault(i => i.Id == caso.EstadoActual).FK_Caso = caso.NumeroCaso;
                dc.SubmitChanges();
            }
        }

        public Caso GetCase(string caseNumber)
        {
            caseNumber = caseNumber.ToUpper();
            Caso retCaso = null;
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                DataLoadOptions dlo = new DataLoadOptions();
                dlo.LoadWith<Caso>(p => p.Historia);
                dlo.LoadWith<Caso>(p => p.Conexion);
                dlo.LoadWith<Caso>(p => p.Conexion1);
                dlo.LoadWith<Caso>(p => p.Solucion);

                dc.LoadOptions = dlo;

                retCaso = dc.Casos.FirstOrDefault(i => i.NumeroCaso.Equals(caseNumber));
            }
            return retCaso;
        }

        public void SaveCase(Caso caso)
        {
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                Caso casoS = dc.Casos.FirstOrDefault(i => i.NumeroCaso.Equals(caso.NumeroCaso));
                casoS.ConexionPruebas = caso.Conexion == null ? casoS.ConexionPruebas : caso.ConexionPruebas;
                casoS.ConexionProduccion = caso.Conexion1 == null ? casoS.ConexionProduccion : caso.ConexionProduccion;
                //casoS.Solucion = caso.Solucion;
                casoS.SolucionActual = caso.SolucionActual == null ? casoS.SolucionActual : caso.SolucionActual;
                casoS.UsuarioAutorizador = caso.UsuarioAutorizador == null ? casoS.UsuarioAutorizador : caso.UsuarioAutorizador;
                casoS.UsuarioProduccion = caso.UsuarioProduccion;
                dc.SubmitChanges();
            }
        }

        public List<Caso> GetCaseListByUserNameAndRoles(string userName, string[] roles)
        {
            List<Caso> retList = new List<Caso>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                DataLoadOptions dlo = new DataLoadOptions();
                dlo.LoadWith<Caso>(p => p.Historia);
                dlo.LoadWith<Caso>(p => p.Conexion);
                dlo.LoadWith<Caso>(p => p.Conexion1);
                dlo.LoadWith<Caso>(p => p.Solucion);
                dc.LoadOptions = dlo;

                IList<Caso> casosAnalista = new List<Caso>();
                IList<Caso> casosAutorizador = new List<Caso>();

                if (roles.Contains(Role.ANALISTA))
                    casosAnalista = dc.Casos.Where((i => i.UsuarioPruebas.Equals(userName) || i.UsuarioProduccion.Equals(userName))).Where(i => i.Historia.Estado.Equals(EstadoCaso.Creado)
                         || i.Historia.Estado.Equals(EstadoCaso.Abierto)
                          || i.Historia.Estado.Equals(EstadoCaso.Guardado)
                           || i.Historia.Estado.Equals(EstadoCaso.DevueltoDesdeAutorizacion)
                            || i.Historia.Estado.Equals(EstadoCaso.AutorizadoAsistido)
                        ).ToList<Caso>();

                if (roles.Contains(Role.AUTORIZADOR))
                    casosAutorizador = dc.Casos.Where(i => i.UsuarioAutorizador.Equals(userName)).Where(
                        i => i.Historia.Estado.Equals(EstadoCaso.Resuelto)
                         || i.Historia.Estado.Equals(EstadoCaso.DevueltoDesdeEjecucion)
                          || i.Historia.Estado.Equals(EstadoCaso.EjecutadoError)

                        ).ToList<Caso>();

                if (roles.Contains(Role.SISTEMA))
                    casosAutorizador = dc.Casos.Where(i => i.Historia.Estado.Equals(EstadoCaso.AutorizadoAutomatico)
                        && i.Solucion.FechaInicio.CompareTo(DateTime.Now) < 0
                        ).ToList<Caso>();
                
                retList.AddRange(casosAnalista);
                retList.AddRange(casosAutorizador);
            }
            return retList;

        }

        public void SetCaseState(string caseNumber, Historia state)
        {
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                Caso caso = dc.Casos.FirstOrDefault(i => i.NumeroCaso.Equals(caseNumber));
                caso.Historia = state;
                dc.SubmitChanges();
                dc.Historias.FirstOrDefault(i => i.Id == caso.EstadoActual).FK_Caso = caso.NumeroCaso;
                dc.SubmitChanges();
            }
        }

        #endregion

        #region IGestorSqlDao Misc

        public DateTime GetDataBaseDateTime()
        {
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                return dc.ExecuteQuery<DateTime>("select getdate()").Single();
        }

        #endregion

        #region IGestorSqlDao Conexion

        public List<Ambiente> GetEnvironmentList(string[] roles)
        {
            List<Ambiente> retList = new List<Ambiente>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                if (roles.Contains(Role.ANALISTA) || roles.Contains(Role.AUTORIZADOR) || roles.Contains(Role.ADMIN))
                {
                    retList.Add(Ambiente.Desarrollo);
                    retList.Add(Ambiente.Pruebas);
                }
                if (roles.Contains(Role.AUTORIZADOR) || roles.Contains(Role.ADMIN))
                {
                    retList.Add(Ambiente.Produccion);
                }
            }
            return retList;
        }

        public List<string> GetServerListByEnvironment(Ambiente environment)
        {
            List<string> retList = new List<string>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Conexions.Where(i => i.Ambiente.Equals((int)environment)).Select<Conexion, string>(i => i.Servidor).Distinct().ToList();
            }
            return retList;
        }

        public List<string> GetServerListByCore(int idCore)
        {
            List<string> retList = new List<string>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Conexions.Where(i => i.Fk_Core == idCore).Select<Conexion, string>(i => i.Servidor).Distinct().ToList();
            }
            return retList;

        }

        public List<string> GetConnectionListByCore(int idCore)
        {
            List<string> retList = new List<string>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Conexions.Where(i => i.Fk_Core == idCore).Select<Conexion, string>(i => i.Nombre).Distinct().ToList();
            }
            return retList;
        }

        public List<string> GetServerList()
        {
            List<string> retList = new List<string>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Conexions.Select<Conexion, string>(i => i.Servidor).Distinct().ToList();
            }
            return retList;
        }

        public Conexion GetConnection(int idConnection)
        {

            Conexion conexion = null;
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                DataLoadOptions dlo = new DataLoadOptions();
                dlo.LoadWith<Conexion>(p => p.Core);
                dc.LoadOptions = dlo;

                var retConn = from c in dc.Conexions
                              where c.IdConexion == idConnection
                              select c;


                conexion = retConn.FirstOrDefault();
            }

            return conexion;

        }

        public Conexion GetConnection(string connectionName)
        {
            Conexion ret = new Conexion();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                DataLoadOptions dlo = new DataLoadOptions();
                dlo.LoadWith<Conexion>(p => p.Core);
                dc.LoadOptions = dlo;

                ret = dc.Conexions.FirstOrDefault(i => i.Nombre.Equals(connectionName));
            }

            return ret;
        }

        public List<Conexion> GetConnectionList()
        {
            List<Conexion> connectionList = new List<Conexion>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                DataLoadOptions dlo = new DataLoadOptions();
                dlo.LoadWith<Conexion>(p => p.Core);
                dc.LoadOptions = dlo;


                connectionList = dc.Conexions.OrderBy(x => x.Servidor).ToList();
            }
            return connectionList;
        }

        public List<string> GetConnectionListByServerAndEnvironment(Ambiente environment, string server)
        {
            List<string> retList = new List<string>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Conexions.Where(i => i.Ambiente.Equals(environment) && i.Servidor.Equals(server)).Select<Conexion, string>(i => i.Nombre).Distinct().ToList();
            }
            return retList;
        }

        public Resultado SaveConnection(Conexion connection)
        {

            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    var conexionExistente = dc.Conexions.FirstOrDefault(i => i.IdConexion == connection.IdConexion);

                    if (conexionExistente != null)
                    {

                        conexionExistente.Ambiente = connection.Ambiente;
                        conexionExistente.BaseDeDatos = connection.BaseDeDatos;
                        conexionExistente.Contrasena = connection.Contrasena;
                        conexionExistente.Nombre = connection.Nombre;
                        conexionExistente.Propiedades = connection.Propiedades;
                        conexionExistente.Servidor = connection.Servidor;
                        conexionExistente.Usuario = connection.Usuario;
                    }

                    else
                        dc.Conexions.InsertOnSubmit(connection);

                    dc.SubmitChanges();

                    return Resultado.Exitoso;

                }
            }
            catch (Exception)
            {
                return Resultado.Fallido;
            }

        }

        public Resultado RemoveConnection(string connectionName)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    var connection = dc.Conexions.FirstOrDefault(i => i.Nombre.Equals(connectionName));
                    dc.Conexions.DeleteOnSubmit(connection);
                    dc.SubmitChanges();

                    return Resultado.Exitoso;

                }
            }
            catch
            {

                return Resultado.Fallido;

            }
        }

        public List<Core> GetCoreList()
        {
            List<Core> retList = null;
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Cores.ToList();
            }
            return retList;
        }
        #endregion

        #region IGestorSqlDao Query
        public List<Query> GetQueriesByCase(string caseNumber)
        {
            List<Query> ret = new List<Query>();
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                ret = dc.Queries.Where(i => i.FK_Caso.Equals(caseNumber)).ToList();
            }
            return ret;
        }

        public long SaveQuery(Query query)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    dc.Queries.InsertOnSubmit(query);
                    dc.SubmitChanges();
                    return query.Id;
                }
            }
            catch (Exception)
            {
                return -1;
            }
        }

        public bool SaveQueryComment(long idQuery, string comment)
        {
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                Query query = dc.Queries.FirstOrDefault(i => i.Id == idQuery);
                if (query != null)
                {
                    query.Comentario = comment;
                    dc.SubmitChanges();
                    return true;
                }
                return false;
            }
        }

        #endregion

        #region IGestorSqlDao Parameters
        public List<Parametro> GetListParameters()
        {
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                return dc.Parametros.ToList();

            }
        }

        public Resultado UpdateParameter(Parametro _parametro)
        {

            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    Parametro parametro = dc.Parametros.Where(x => x.IdParametro == _parametro.IdParametro).FirstOrDefault();

                    parametro.Valor = _parametro.Valor;
                    parametro.Descripcion = _parametro.Descripcion;

                    dc.SubmitChanges();

                    return Resultado.Exitoso;
                }
            }
            catch
            {

                return Resultado.Fallido;
            }
        }

        public object GetParameter(string key)
        {
            object retVal = null;
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                Parametro par = dc.Parametros.FirstOrDefault(i => i.Codigo.Equals(key));
                if (par != null)
                    retVal = par.Valor;
            }
            return retVal;
        }

        public string GetValueFromParameter(string codigo)
        {

            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    var par = dc.Parametros.Where(x => x.Codigo.Equals(codigo)).FirstOrDefault();

                    return par.Valor;
                }


            }
            catch
            {
                return string.Empty;
            }




            throw new NotImplementedException();
        }

        #endregion

        #region IGestorSqlDao Security
        public Resultado SaveUsersInRoles(List<UserInRole> userInRoleList)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    foreach (UserInRole userInRole in userInRoleList)

                        dc.UserInRoles.InsertOnSubmit(userInRole);


                    dc.SubmitChanges();

                    return Resultado.Exitoso;


                }

            }
            catch
            {

                return Resultado.Fallido;


            }


        }

        public Resultado DeleteUsersInRole(string userName)
        {
            try
            {

                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    var usersInRole = dc.UserInRoles.Where(x => x.Usuario.Equals(userName.Trim()));

                    foreach (var userInRoleItem in usersInRole)
                        dc.UserInRoles.DeleteOnSubmit(userInRoleItem);


                    dc.SubmitChanges();
                    return Resultado.Exitoso;
                }

            }
            catch
            {

                return Resultado.Fallido;


            }
        }

        public List<UserInRole> GetUserInRoleList()
        {

            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {


                    DataLoadOptions dlo = new DataLoadOptions();
                    dlo.LoadWith<UserInRole>(p => p.Role);

                    dc.LoadOptions = dlo;


                    return dc.UserInRoles.ToList();
                }

            }

            catch
            {

                return new List<UserInRole>();


            }


        }

        public List<UserInRole> GetUsersList()
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    DataLoadOptions dlo = new DataLoadOptions();
                    dlo.LoadWith<UserInRole>(p => p.Role);

                    dc.LoadOptions = dlo;


                    var userInRoles = from ur in dc.UserInRoles
                                      group ur by ur.Usuario into g
                                      select g.First();




                    return userInRoles.ToList();

                }
            }


            catch
            {

                return new List<UserInRole>();


            }
        }

        public List<Role> GetRoleList()
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    DataLoadOptions dlo = new DataLoadOptions();
                    dlo.LoadWith<UserInRole>(p => p.Role);
                    dc.LoadOptions = dlo;

                    return dc.Roles.ToList();
                }
            }

            catch
            {

                return new List<Role>();


            }
        }

        #endregion

        #region IGestorSqlDao Log
        public long SaveLog(Log log)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    dc.Logs.InsertOnSubmit(log);
                    dc.SubmitChanges();
                    return log.IdLog;
                }
            }
            catch
            {

                return -1;
            }
        }

        #endregion

        #region IGestorSqlDao ConjuntoSolucion
        public Resultado SaveConjuntoSolucion(ConjuntoSolucion conjuntoSolucion)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    dc.ConjuntoSolucions.InsertOnSubmit(conjuntoSolucion);
                    dc.SubmitChanges();
                    return Resultado.Exitoso;

                }
            }
            catch
            {

                return Resultado.Fallido;
            }
        }

        public Resultado SaveConjuntosSolucion(List<ConjuntoSolucion> conjuntoSolucionList)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    dc.ConjuntoSolucions.InsertAllOnSubmit(conjuntoSolucionList);
                    dc.SubmitChanges();
                    return Resultado.Exitoso;

                }
            }
            catch
            {

                return Resultado.Fallido;
            }
        }

        #endregion

        #region IGestorSqlDao Solcion
        public Solucion GetSolucionByCase(Caso caso)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    DataLoadOptions dlo = new DataLoadOptions();
                    dlo.LoadWith<Solucion>(p => p.Caso);
                    dc.LoadOptions = dlo;


                    var soluciones = from s in dc.Solucions
                                     where s.IdSolucion == caso.SolucionActual.Value
                                     select s;

                    return soluciones.FirstOrDefault();

                }
            }
            catch
            {

                return new Solucion();
            }
        }

        public long SaveSolution(Solucion solucion)
        {
            if ((TipoEjecucion)solucion.TipoEjecucion == TipoEjecucion.Automatico) solucion.UsuarioEjecuta = "UsrAutomatic".GetFromAppCfg();
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    dc.Solucions.InsertOnSubmit(solucion);
                    dc.SubmitChanges();
                    return solucion.IdSolucion;
                }
            }
            catch
            {
                return -1;
            }
        }

        public Resultado UpdateSolution(Solucion solucion)
        {

            if ((TipoEjecucion)solucion.TipoEjecucion == TipoEjecucion.Automatico) solucion.UsuarioEjecuta = "UsrAutomatic".GetFromAppCfg();
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    Solucion currentSolucion = dc.Solucions.Where(x => x.IdSolucion == solucion.IdSolucion).FirstOrDefault();


                    currentSolucion.TipoEjecucion = solucion.TipoEjecucion;
                    currentSolucion.FechaInicio = solucion.FechaInicio;
                    currentSolucion.FechaFin = solucion.FechaFin;
                    currentSolucion.UsuarioEjecuta = solucion.UsuarioEjecuta;
                    currentSolucion.FK_Conexion = solucion.FK_Conexion;

                    dc.SubmitChanges();

                    return Resultado.Exitoso;
                }
            }
            catch
            {

                return Resultado.Fallido;
            }

        }

        #endregion

        #region IGestorSqlDao Asignaciones
        public Resultado SaveAssignment(string userName)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    dc.Asignaciones.InsertOnSubmit(new Asignacione() { CasosActivos = 0, UsuarioAutorizador = userName });
                    dc.SubmitChanges();
                    return Resultado.Exitoso;

                }
            }
            catch
            {

                return Resultado.Fallido;
            }
        }

        public Resultado UpdateAssigment(string userName, int casosActivos)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    Asignacione assignment = dc.Asignaciones.Where(x => x.UsuarioAutorizador.Equals(userName)).FirstOrDefault();

                    assignment.CasosActivos = casosActivos;

                    dc.SubmitChanges();
                    return Resultado.Exitoso;

                }
            }
            catch
            {

                return Resultado.Fallido;
            }
        }

        public Asignacione GetAssignment(string userName)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    return dc.Asignaciones.Where(x => x.UsuarioAutorizador.Equals(userName)).FirstOrDefault();

                }
            }
            catch
            {

                return null;
            }

        }

        public List<Asignacione> GetAssignmentList()
        {
            List<Asignacione> retList = null;
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                retList = dc.Asignaciones.ToList();
            }
            return retList;
        }

        public Resultado RemoveAssignment(string userName)
        {
            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    var assignment = dc.Asignaciones.Where(x => x.UsuarioAutorizador.Equals(userName)).FirstOrDefault();

                    dc.Asignaciones.DeleteOnSubmit(assignment);
                    dc.SubmitChanges();

                    return Resultado.Exitoso;
                }
            }
            catch
            {

                return Resultado.Fallido;
            }
        }

        #endregion

        #region IGestorSqlDao Core

        public Core GetCoreById(int coreId)
        {
            Core ret = null;
            using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
            {
                ret = dc.Cores.FirstOrDefault(i => i.Id.Equals(coreId));
            }
            return ret;
        }

        #endregion

        #region IGestorSqlDao Log


        public List<Log> GetLogsByBySolution(long idSolution)
        {
            List<Log> logList = new List<Log>();

            try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {
                    logList = dc.Logs.Where(x => x.Fk_Solucion == idSolution).ToList();
                    return logList;
                }
            }
            catch
            {
                return logList;
            }
        }

        #endregion

        #region IGestorSqlDao Members


        public List<ConsultaCaso> ViewCasesByParameters(string caseNumber, string usuarioAnalista, string usuarioDueño, DateTime? fechaInicio, DateTime? fechaFin, bool soloEjecucionesAsistidas)
        {

          
            List<ConsultaCaso> consultaCasoList = new List<ConsultaCaso>();

             try
            {
                using (GestorEntitiesDataContext dc = new GestorEntitiesDataContext(StrConn))
                {

                    DataLoadOptions dlo = new DataLoadOptions();
                    dlo.LoadWith<Caso>(p => p.Solucion);
                    dlo.LoadWith<Caso>(p => p.Conexion);
                    dlo.LoadWith<Caso>(p => p.Conexion1);
                    dlo.LoadWith<Caso>(p => p.Historia);
                    dc.LoadOptions = dlo;



                    var result3 = from s in dc.Solucions
                                  join c in dc.Casos on s.FK_Caso equals c.NumeroCaso
                                  where c.NumeroCaso.Contains(caseNumber) &&
                                  c.UsuarioPruebas.Contains(usuarioAnalista) &&
                                  c.UsuarioDueno.Contains(usuarioDueño)
                                  select new { c.NumeroCaso, s.IdSolucion, c.UsuarioPruebas, s.UsuarioEjecuta, c.UsuarioAutorizador, c.UsuarioDueno, s.FechaInicio, s.FechaFin, s.TipoEjecucion };

                    

                    //var result2 = from c in dc.Casos
                    //              where c.NumeroCaso.Contains(caseNumber) &&
                    //              c.UsuarioPruebas.Contains(usuarioAnalista) &&
                    //              c.UsuarioDueno.Contains(usuarioDueño)
                    //              select c;

                    //if (fechaInicio != null && fechaFin == null)
                    //    result2 = result2.Where(x => x.Solucion.FechaInicio >= fechaInicio);
                    //else if (fechaInicio == null && fechaFin != null)
                    //    result2 = result2.Where(x => x.Solucion.FechaFin <= fechaFin);
                    //else if (fechaInicio != null && fechaFin != null)
                    //    result2 = result2.Where(x => x.Solucion.FechaFin <= fechaFin && x.Solucion.FechaInicio >= fechaInicio);


                    if (fechaInicio != null && fechaFin == null)
                        result3 = result3.Where(x => x.FechaInicio >= fechaInicio);
                    else if (fechaInicio == null && fechaFin != null)
                        result3 = result3.Where(x => x.FechaFin <= fechaFin);
                    else if (fechaInicio != null && fechaFin != null)
                        result3 = result3.Where(x => x.FechaFin <= fechaFin && x.FechaInicio >= fechaInicio);

                    if (soloEjecucionesAsistidas)
                        result3 = result3.Where(x => x.TipoEjecucion == 0);


                    foreach (var item in result3)
                    {

                        consultaCasoList.Add(new ConsultaCaso()
                        {
                            NumeroCaso = item.NumeroCaso,
                            FechaFin = item.FechaFin,
                            FechaInicio = item.FechaInicio,
                            IdSolucion = item.IdSolucion,
                            UsuarioAutorizador = item.UsuarioAutorizador,
                            UsuarioDueno = item.UsuarioDueno,
                            UsuarioEjecuta = item.UsuarioEjecuta,
                            UsuarioPruebas = item.UsuarioPruebas

                        });

                    }

                    return consultaCasoList;
                }
            }
            catch
            {
                return consultaCasoList;
            }


        }

        #endregion


    }

}
